package com.xuecheng.content.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xuecheng.api.content.model.dto.CourseBaseDTO;
import com.xuecheng.api.content.model.qo.QueryCourseBaseModel;
import com.xuecheng.common.domain.code.CommonErrorCode;
import com.xuecheng.common.domain.page.PageRequestParams;
import com.xuecheng.common.domain.page.PageVO;
import com.xuecheng.common.enums.common.CommonEnum;
import com.xuecheng.common.enums.content.CourseAuditEnum;
import com.xuecheng.common.enums.content.CourseChargeEnum;
import com.xuecheng.common.exception.ExceptionCast;
import com.xuecheng.common.util.StringUtil;
import com.xuecheng.content.common.constant.ContentErrorCode;
import com.xuecheng.content.convert.CourseBaseConvert;
import com.xuecheng.content.entity.CourseBase;
import com.xuecheng.content.entity.CourseMarket;
import com.xuecheng.content.mapper.CourseBaseMapper;
import com.xuecheng.content.service.CourseBaseService;
import com.xuecheng.content.service.CourseMarketService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.Collections;
import java.util.List;

/**
 * <p>
 * 课程基本信息 服务实现类
 * </p>
 *
 * @author itcast
 */
@Slf4j
@Service
public class CourseBaseServiceImpl extends ServiceImpl<CourseBaseMapper, CourseBase> implements CourseBaseService {

    @Autowired
    private CourseMarketService courseMarketService;

    /*
     * 步骤分析：
     *  1.是否需要开启事务
     *  2.判断关键数据
     *       分页数据
     *       查询条件
     *  3.构建mp分页对象
     *  4.构建查询条件对象LambdaQueryWrapper
     *  5.查询数据
     *  6.获得数据并封装返回结果
     *       封装PageVo数据
     * */
    @Override
    public PageVO queryCourseBaseList(PageRequestParams params, QueryCourseBaseModel model, Long companyId) {

        //1.是否需要开启事务
        // 查询无需开启事务
        // 2.判断关键数据
        //      分页数据
        //      查询条件

        // 2.1 判断分页数据
        Long pageNo = params.getPageNo();
        Integer pageSize = params.getPageSize();

        if (ObjectUtils.isEmpty(pageNo) || pageNo < 0) {
            params.setPageNo(PageRequestParams.DEFAULT_PAGE_NUM);
        }

        if (ObjectUtils.isEmpty(pageSize) || pageSize < 0) {
            params.setPageSize(PageRequestParams.DEFAULT_PAGE_SIZE);
        }

        // 2.2.构建查询条件对象LambdaQueryWrapper
        // 完成第四部中的构建查询条件
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();

        // 完整版
        // select * from course_base where name = ? and auditStatus = ? and companyId = ?
        // if (StringUtil.isNotBlank(model.getCourseName())) {
        //     queryWrapper.eq(CourseBase::getName,model.getCourseName());
        // }
        //
        // if (StringUtil.isNotBlank(model.getAuditStatus())) {
        //     queryWrapper.eq(CourseBase::getAuditStatus,model.getAuditStatus());
        // }

        // 简版
        queryWrapper.like(StringUtil.isNotBlank(model.getCourseName()),CourseBase::getName,model.getCourseName());
        queryWrapper.eq(StringUtil.isNotBlank(model.getAuditStatus()),CourseBase::getAuditStatus,model.getAuditStatus());
        queryWrapper.eq(!(ObjectUtils.isEmpty(companyId)),CourseBase::getCompanyId,companyId);
        queryWrapper.eq(CourseBase::getStatus, CommonEnum.USING_FLAG.getCode());
        // 3.构建mp分页对象
        Page<CourseBase> page = new Page<>(params.getPageNo(),params.getPageSize());


        // 5.查询数据
        Page<CourseBase> pageResult = this.page(page, queryWrapper);

        // 获得当前页的集合数据
        List<CourseBase> records = pageResult.getRecords();

        // 查询数据的总记录数
        long total = pageResult.getTotal();


        // 将po数据转为dto数据
        List<CourseBaseDTO> dtos = Collections.EMPTY_LIST;


        if (!(CollectionUtils.isEmpty(records))) {
            dtos = CourseBaseConvert.INSTANCE.entity2dto(records);
        }



        // 6.获得数据并封装返回结果
        //      封装PageVo数据
        PageVO pageVO = new PageVO(dtos, total, params.getPageNo(), params.getPageSize());

        return pageVO;
    }


    /**
     * 业务分析
     *      1，是否开启事务
     *          新增操作需要开启事务
     *          （如果新增操作只会操作一张表而且只会操作一次，那么可以忽略事务）
     *      2，判断关键数据
     *          课程基础捏成
     *              关键数据：表中内容的必要数据，无此数据代表数据不完整
     *              关键数据的来源：
     *                  1，数据库的约束：不能为空的字段
     *                  2，前端页面中必要数据：用小红点来显示
     *                  3，接口文档：Yapi 会体现出必要的数据
     *      3，将dto转为po数据，并且赋值审核状态的默认值
     *          保存：未提交
     *      4，保存数据
     *         4.1 保存课程基础信息：判断保存的结果
     *         4.2 保存课程营销信息：判断保存的结果
     *      5，将数据库的最新数据转为dto并返回
     *
     * @param dto
     * @return
     */
    @Override
    @Transactional
    public CourseBaseDTO createCourseBase(CourseBaseDTO dto) {
        //判断关键数据
        verifyCourseMsg(dto);

        //将dto转为po数据，并且赋值审核状态的默认值
        CourseBase courseBase = CourseBaseConvert.INSTANCE.dto2entity(dto);

        // 保存：设置成未提交
        courseBase.setAuditStatus(CourseAuditEnum.AUDIT_UNPAST_STATUS.getCode());

        //4,保存数据
        //  4.1保存课程基础信息
        //      判断保存的结果
        //   如果mp对数据保存成功后，会将保存成功在数据库中的id值返回给courBase中
        boolean baseResult = this.save(courseBase);

        if(!baseResult){
            throw new RuntimeException("保存课程基础信息失败");
        }

        //4.2 保存课程营销信息
        //判断保存的结果
        CourseMarket courseMarket = new CourseMarket();

        courseMarket.setCourseId(courseBase.getId());
        courseMarket.setCharge(dto.getCharge());

        //判断课程是否收费
        //    1,如果课程是免费，无需给price赋值
        if(CourseChargeEnum.CHARGE_YES.getCode().equals(dto.getCharge())){
            //如果是收费，price必须有值
            if(ObjectUtils.isEmpty(dto.getPrice())){
                throw new RuntimeException("收费课程价格不能为空");
            }
        }

        courseMarket.setPrice(dto.getPrice().floatValue());

        boolean marketResult = courseMarketService.save(courseMarket);

        if(!marketResult){
            throw new RuntimeException("保存课程营销信息失败");
        }

        //将数据库的最新数据转为dto并返回
        CourseBaseDTO resultDTO = CourseBaseConvert.INSTANCE.entity2dto(courseBase);
        resultDTO.setCharge(dto.getCharge());
        resultDTO.setPrice(dto.getPrice());

        return resultDTO;
    }


    /*
     * 业务分析：
     *   1.判断关键数据
     *       courseId、companyId
     *   2.判断业务数据
     *       课程基础信息
     *           课程是否是同一家教学机构
     *           判断课程是否已删除
     *   3.将数据转为dto并返回
     * */
    @Override
    public CourseBaseDTO getByCourseId(Long courseId, Long companyId) {


        //1.判断关键数据
        //     courseId、companyId

        // 2.判断业务数据
        //     课程基础信息
        //         课程是否是同一家教学机构
        //         判断课程是否已删除
        // 2.1 课程是否是同一家教学机构
        // 2.2 判断课程是否已删除
        // 2.1 课程是否是同一家教学机构
        CourseBase courseBase = getCourseBaseAndLogicVerify(courseId, companyId);


        // 3.将数据转为dto并返回
        //  获得课程的营销数据并返回
        CourseBaseDTO dto = CourseBaseConvert.INSTANCE.entity2dto(courseBase);

        LambdaQueryWrapper<CourseMarket> marketQueryWrapper = new LambdaQueryWrapper<>();
        marketQueryWrapper.eq(CourseMarket::getCourseId, courseId);

        CourseMarket market = courseMarketService.getOne(marketQueryWrapper);

        dto.setPrice(new BigDecimal(market.getPrice().toString()));
        dto.setCharge(market.getCharge());

        return dto;
    }


    /*
     * 业务分析：
     *   1.判断关键数据
     *      参考添加的判断
     *   2.判断业务数据
     *       课程基础信息
     *           判断是否是同一家教学机构
     *           判断课程是否被删除
     *           判断课程的审核状态
     *               只有 未提交、审核未通过 才可以修改数据
     *   3.转换dto数据为po数据
     *   4.修改数据
     *       课程基础信息
     *       课程营销信息
     *
     *   5.将最新数据返回给dto
     * */
    @Override
    @Transactional
    public CourseBaseDTO modifyCourseBase(CourseBaseDTO dto) {

        //1.判断关键数据
        //    参考添加的判断
        verifyCourseMsg(dto);

        if (ObjectUtils.isEmpty(dto.getCourseBaseId())) {
            throw new RuntimeException("修改课程id不能为空");
        }

        // 2.判断业务数据
        //     课程基础信息
        //         判断是否是同一家教学机构
        //         判断课程是否被删除
        //         判断课程的审核状态
        //             只有 未提交、审核未通过 才可以修改数据

        // 修改的数据必须要有Id值
        CourseBase courseBase = getCourseBaseAndLogicVerify(dto.getCourseBaseId(), dto.getCompanyId());

        String auditStatus = courseBase.getAuditStatus();
        if (CourseAuditEnum.AUDIT_PASTED_STATUS.getCode().equals(auditStatus)||
                CourseAuditEnum.AUDIT_PUBLISHED_STATUS.getCode().equals(auditStatus)||
                CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode().equals(auditStatus)
        ) {
            throw new RuntimeException("课程审核状态异常");
        }



        // 3.转换dto数据为po数据
        CourseBase po = CourseBaseConvert.INSTANCE.dto2entity(dto);

        // CourseMarket courseMarket = new CourseMarket();
        // courseMarket.setPrice(dto.getPrice().floatValue());
        // courseMarket.setCharge(dto.getCharge());


        // 4.修改数据
        //     课程基础信息

        // 如果修改的实体数据比较多，updateById（要修改的实体类对象）
        boolean courseResult = this.updateById(po);

        if (!courseResult) {
            throw new RuntimeException("修改课程基础信息失败");
        }

        //     课程营销信息
        // 如果修改的实体数据比较少，LambdaUpdateWrapper
        // update course_market set charge = ? ,  price = ? where courseid =?
        LambdaUpdateWrapper<CourseMarket> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(CourseMarket::getCharge,dto.getCharge());

        float price = 0f;
        if (CourseChargeEnum.CHARGE_YES.getCode().equals(dto.getCharge())) {
            price = dto.getPrice().floatValue();
        }
        updateWrapper.set(CourseMarket::getPrice, price);


        updateWrapper.eq(CourseMarket::getCourseId,dto.getCourseBaseId());

        boolean marketResult = courseMarketService.update(updateWrapper);

        if (!marketResult) {
            throw new RuntimeException("修改课程营销信息失败");
        }


        // 5.将最新数据返回给dto
        CourseBase resultPO = this.getById(dto.getCourseBaseId());

        CourseBaseDTO resultDTO = CourseBaseConvert.INSTANCE.entity2dto(resultPO);

        resultDTO.setCharge(dto.getCharge());
        resultDTO.setPrice(dto.getPrice());

        return resultDTO;
    }


    /**
     * 业务分析：
     *   1.判断关键数据的合法性
     *   2.根据Id获得课程基础信息并进行相应的判断
     *      2.1 获得课程基础信息
     *      2.2 判断课程的审核状态
     *   3.修改课程信息状态值
     * @param courseId - 课程id
     * @param companyId - 公司id
     */
    @Override
    @Transactional
    public void removeCourseBase(Long courseId, Long companyId) {

        //1.判断关键数据的合法性
        verifyCourseIdAndCompanyIdIsEmpty(courseId,companyId);

        //2.根据Id获得课程基础信息并进行相应的判断
        //2.1 获得课程基础信息
        CourseBase courseBase = getById(courseId);
        if (ObjectUtils.isEmpty(courseBase)){
            ExceptionCast.cast(ContentErrorCode.E_120013);
        }
        Long queryCourseId = courseBase.getId();

        //这个方法是原始方法，被更好的替代了，留着以防万一
//        verifyPO(companyId, courseBase);
        getCourseBaseAndLogicVerify(queryCourseId,companyId);


        //2.2 判断课程的审核状态
        String auditStatus = courseBase.getAuditStatus();

        if (CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode().equals(auditStatus) ||
                CourseAuditEnum.AUDIT_PASTED_STATUS.getCode().equals(auditStatus) ||
                CourseAuditEnum.AUDIT_PUBLISHED_STATUS.getCode().equals(auditStatus)
        ) {
            ExceptionCast.cast(ContentErrorCode.E_120015);
        }

        // 3.修改课程信息状态值
        LambdaUpdateWrapper<CourseBase> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(CourseBase::getStatus,CommonEnum.DELETE_FLAG.getCodeInt());
        updateWrapper.set(CourseBase::getChangeDate, LocalDateTime.now());

        updateWrapper.eq(CourseBase::getId, courseBase.getId());

        boolean result = update(updateWrapper);
        if (!result) {
            ExceptionCast.cast(ContentErrorCode.E_120017);
        }


    }

    /*
     * 业务分析：
     *   1.判断关键数据
     *       courseBaseId  companyId
     *   2.判断业务数据
     *       课程基础信息
     *           判断课程是否存在
     *           判断是否是同一家机构
     *           判断课程是否被删除
     *           判断课程的审核状态
     *   3.提交课程
     *       修改课程基础信息的审核状态：已提交
     *   4.判断修改后的结果内容
     * */
    @Override
    @Transactional
    public void commitCourseBase(Long courseBaseId, Long companyId) {
        //1.判断关键数据
        //     courseBaseId  companyId

        // 2.判断业务数据
        //     课程基础信息
        //         判断课程是否存在
        //         判断是否是同一家机构
        //         判断课程是否被删除
        CourseBase courseBase = getCourseBaseAndLogicVerify(courseBaseId, companyId);

        String auditStatus = courseBase.getAuditStatus();

        if (CourseAuditEnum.AUDIT_PUBLISHED_STATUS.getCode().equals(auditStatus)||
                CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode().equals(auditStatus)||
                CourseAuditEnum.AUDIT_PASTED_STATUS.getCode().equals(auditStatus)
        ) {
            ExceptionCast.cast(ContentErrorCode.E_120015);
        }



        // 3.提交课程
        //     修改课程基础信息的审核状态：已提交

        // 优化前：
        //  updateById:会将coursebase中的所有的属性进行修改，修改的效率低
        // courseBase.setAuditStatus(CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode());
        // this.updateById(courseBase);


        // PS：对象属性很多，修改的内容很少
        // 优化后：
        // 需要修改什么数据，就只修改指定的属性
        // update course_base set audit_status = xxx ,change_date = xxx where course_id = xxx
        // UpdateWrapper注意：自动填充的功能将会失效
        LambdaUpdateWrapper<CourseBase> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(CourseBase::getAuditStatus, CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode());
        updateWrapper.set(CourseBase::getChangeDate, LocalDateTime.now());
        updateWrapper.eq(CourseBase::getId, courseBaseId);

        // 4.判断修改后的结果内容
        boolean result = this.update(updateWrapper);
        ExceptionCast.cast(!result,ContentErrorCode.E_120017);

    }


    /*
     * 业务分析：
     *   1.判断关键数据
     *       courseId           课程id
     *       courseAuditStatus  课程审核状态
     *       courseAutditMind   课程审核意见
     *   2.判断业务数据
     *       课程基础信息
     *           判断课程是否存在
     *           判断课程是否删除
     *           判断课程审核状态：只能是已提交
     *       运营平台的审核状态
     *           只能是 审核通过或审核未通过
     *   3.修改课程审核的数据
     *       修改CourseBase表
     *           audtiStatus
     *           auditMind
     *           auditNum
     *           changeDate
     *
     *   4.判断修改的结果
     * */
    @Transactional
    @Override
    public void approve(CourseBaseDTO courseBaseDTO) {
        //1.判断关键数据
        //     courseId           课程id
        //     courseAuditStatus  课程审核状态
        //     courseAutditMind   课程审核意见
        String auditStatus = courseBaseDTO.getAuditStatus();
        if (ObjectUtils.isEmpty(courseBaseDTO.getCourseBaseId())||
                StringUtil.isBlank(auditStatus)||
                StringUtil.isBlank(courseBaseDTO.getAuditMind())
        ) {
            ExceptionCast.cast(CommonErrorCode.E_100101);
        }


        // 2.判断业务数据
        //     课程基础信息
        //            判断课程是否存在
        //         判断课程是否删除
        //         判断课程审核状态：只能是已提交
        // 2.1  课程基础信息
        CourseBase courseBase = this.getById(courseBaseDTO.getCourseBaseId());

        // 判断课程是否存在
        ExceptionCast.cast(ObjectUtils.isEmpty(courseBase),ContentErrorCode.E_120013);

        // 判断课程是否删除
        ExceptionCast.cast(CommonEnum.DELETE_FLAG.getCodeInt().equals(courseBase.getStatus()),
                ContentErrorCode.E_120020);

        // 判断课程审核状态：只能是已提交
        ExceptionCast.cast(!(CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode().equals(courseBase.getAuditStatus())),
                ContentErrorCode.E_120015);

        // 2.2  判断运营平台的审核状态
        //      运营平台：只能是 审核通过或审核未通过
        if (CourseAuditEnum.AUDIT_PUBLISHED_STATUS.getCode().equals(auditStatus)||
                CourseAuditEnum.AUDIT_UNPAST_STATUS.getCode().equals(auditStatus)||
                CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode().equals(auditStatus)
        ) {
            ExceptionCast.cast(CommonErrorCode.E_100117);
        }


        // 3.修改课程审核的数据
        //     修改CourseBase表
        //         audtiStatus
        //         auditMind
        //         auditNum
        //         changeDate
        LambdaUpdateWrapper<CourseBase> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(CourseBase::getAuditStatus, auditStatus);
        updateWrapper.set(CourseBase::getAuditMind, courseBaseDTO.getAuditMind());
        updateWrapper.set(CourseBase::getAuditNums, courseBase.getAuditNums()+1);
        updateWrapper.set(CourseBase::getChangeDate, LocalDateTime.now());
        updateWrapper.eq(CourseBase::getId, courseBase.getId());

        // 4.判断修改的结果
        boolean result = this.update(updateWrapper);
        ExceptionCast.cast(!result,ContentErrorCode.E_120017);
    }


    /**
     * 这是原始的方法，不过被楼下的新方法替代了。留着以防万一
     *
     * 1，判断课程信息是否存在
     * 2，判断是否是同一家公司
     * //@param companyId - 公司令牌
     * //@param courseBase - 课程实体类
     */
//    private void verifyPO(Long companyId, CourseBase courseBase) {
//        // 判断课程数据是否存在
//        if (ObjectUtils.isEmpty(courseBase)) {
//            ExceptionCast.cast(ContentErrorCode.E_120013);
//        }
//
//        // 判断是否是同一家机构
//        if (!(ObjectUtils.nullSafeEquals(companyId, courseBase.getCompanyId()))) {
//            ExceptionCast.cast(CommonErrorCode.E_100108);
//        }
//    }


    /**
     * 判断关键数据是否存在
     *   getCompanyId
     *   getName
     *   getMt
     *   getSt
     *   getGrade
     *   getTeachmode
     *   getUsers
     *   getCharge
     * @param dto - CourseBaseDTO
     */
    private void verifyCourseMsg(CourseBaseDTO dto){
        //2.判断关键数据
        //课程基础信息
        //companyID name mt st grade teachmode user pic（后期来判断）
        if(ObjectUtils.isEmpty(dto.getCompanyId())){
            //业务异常：程序员在做业务判断时，数据有问题
            //异常：
            // 1，终止程序
            // 2，传递错误信息
            // 3，使用运行时异常来抛出：运行时异常不需在编译期间处理
            ExceptionCast.cast(CommonErrorCode.E_403001);
        }

        if(StringUtil.isBlank(dto.getName())){
//            throw new RuntimeException("课程名称不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120004);
        }

        if(StringUtil.isBlank(dto.getMt())){
//            throw new RuntimeException("课程大分类不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120002);
        }

        if(StringUtil.isBlank(dto.getSt())){
//            throw new RuntimeException("课程小分类不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120003);
        }

        if(StringUtil.isBlank(dto.getGrade())){
//            throw new RuntimeException("课程等级不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120007);
        }

        if(StringUtil.isBlank(dto.getTeachmode())){
//            throw new RuntimeException("课程教学模式不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120006);
        }

        if(StringUtil.isBlank(dto.getUsers())){
//            throw new RuntimeException("使用人群不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120018);
        }

        if(StringUtil.isBlank(dto.getCharge())){
//            throw new RuntimeException("课程收费不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120019);
        }
    }


    /**
     * 分别判断课程id和公司令牌是否为空
     * @param courseId - 课程id
     * @param companyId - 公司令牌
     */
    private void verifyCourseIdAndCompanyIdIsEmpty(Long courseId, Long companyId) {
        if (ObjectUtils.isEmpty(courseId)) {
            //数据的ID值不能为空
            ExceptionCast.cast(ContentErrorCode.E_120009);
        }
        if (ObjectUtils.isEmpty(companyId)) {
            //公司id不能为空
            ExceptionCast.cast(CommonErrorCode.E_403001);
        }
    }


    /**
     * 1，首先判断courseId和companyId是否存在
     * 2，然后再判断公司下有没有这门课
     * 3，判断这门课是否删除。
     * @param courseId - 课程id
     * @param companyId - 公司令牌
     * @return - 返回查询到的这个公司的这门课的实体类信息
     */
    private CourseBase getCourseBaseAndLogicVerify(Long courseId, Long companyId) {
        //判断courseId和companyId是否存在
        verifyCourseIdAndCompanyIdIsEmpty(courseId, companyId);

        //再判断公司下有没有这门课
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CourseBase::getId, courseId);
        queryWrapper.eq(CourseBase::getCompanyId, companyId);

        CourseBase courseBase = this.getOne(queryWrapper);

        if (ObjectUtils.isEmpty(courseBase)) {
            //课程信息不存在
            ExceptionCast.cast(ContentErrorCode.E_120013);
        }

        // 2.2 判断课程是否已删除
        Integer status = courseBase.getStatus();
        if (CommonEnum.DELETE_FLAG.getCodeInt().equals(status)) {
            //课程基础信息已删除
            ExceptionCast.cast(ContentErrorCode.E_120020);
        }
        return courseBase;
    }

}
